home *** CD-ROM | disk | FTP | other *** search
/ Aminet 15 / Aminet 15 - Nov 1996.iso / Aminet / text / hyper / hsc_source.lha / source / hscprj / document.c < prev    next >
C/C++ Source or Header  |  1996-09-10  |  9KB  |  402 lines
  1. /*
  2.  * hsclib/document.c
  3.  *
  4.  * document routines for hsc
  5.  *
  6.  * Copyright (C) 1996  Thomas Aglassinger
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  *
  22.  * updated:  9-Sep-1996
  23.  * created:  7-Jul-1996
  24.  */
  25.  
  26. #include <stdio.h>
  27. #include <string.h>
  28.  
  29. #include "hscprj/document.h"
  30.  
  31. /* debuggin define */
  32. #ifdef D
  33. #undef D
  34. #endif
  35. #if DEBUG
  36. #define D(x) x
  37. #else
  38. #define D(x)                    /* nufin */
  39. #endif
  40.  
  41. /*
  42.  * call_panic
  43.  *
  44.  * panic message; called by "panic()"-macro
  45.  */
  46. VOID call_panic(STRPTR text, STRPTR file, ULONG line)
  47. {
  48.     fprintf(stderr, "\n##\n## illegal state in `%s' (%lu): %s\n##\n",
  49.             file, line, text);
  50. }
  51.  
  52. /*
  53.  * del/new_document
  54.  */
  55.  
  56. /* del_document: remove document */
  57. VOID del_document(APTR data)
  58. {
  59.     if (data) {
  60.         HSCDOC *document = (HSCDOC *) data;
  61.  
  62.         ufreestr(document->docname);
  63.         ufreestr(document->sourcename);
  64.         del_estr(document->title);
  65.         del_dllist(document->iddefs);
  66.         del_dllist(document->includes);
  67.         del_dllist(document->references);
  68.         ufree(document);
  69.     }
  70. }
  71.  
  72. /* new_document: create new document */
  73. HSCDOC *new_document(STRPTR docname)
  74. {
  75.     HSCDOC *newdoc = (HSCDOC *) umalloc(sizeof(HSCDOC));
  76.  
  77. #if 0
  78.     DP(fprintf(stderr, DHP "new document `%s'\n", docname));
  79. #endif
  80.     newdoc->docname = strclone(docname);
  81.     newdoc->sourcename = NULL;
  82.     newdoc->title = init_estr(0);
  83.     newdoc->iddefs = init_dllist(del_iddef);
  84.     newdoc->includes = init_dllist(del_include);
  85.     newdoc->references = init_dllist(del_reference);
  86.  
  87.     return (newdoc);
  88. }
  89.  
  90. /*
  91.  * cmp_document: compare document
  92.  */
  93. int cmp_document(APTR cmp_data, APTR list_data)
  94. {
  95.     HSCDOC *document = (HSCDOC *) list_data;
  96.     STRPTR fname1 = NULL;
  97.     STRPTR fname2 = (STRPTR) cmp_data;
  98.  
  99. #if DEBUG
  100.     if (!document)
  101.         panic("documant = NULL");
  102.     else if (!document->docname)
  103.         panic("fname1 = NULL");
  104.     if (!fname2)
  105.         panic("fname2 = NULL");
  106. #endif
  107.     fname1 = document->docname;
  108.  
  109.     if (!strcmp(fname1, fname2))
  110.         return (-1);
  111.     else
  112.         return (0);
  113. }
  114.  
  115.  
  116. /* find_document_node: scans document list for a specific document */
  117. DLNODE *find_document_node(DLLIST *list, STRPTR name)
  118. {
  119.     return( find_dlnode(dll_first(list), (APTR) name, cmp_document));
  120. }
  121.  
  122. /* find_document: scans document list for a specific document */
  123. HSCDOC *find_document(DLLIST * list, STRPTR name)
  124. {
  125.     DLNODE *nd = find_document_node(list, name);
  126.     HSCDOC *document = NULL;
  127.  
  128.     if (nd)
  129.         document = (HSCDOC *) dln_data(nd);
  130.  
  131.     return (document);
  132. }
  133.  
  134. /*
  135.  * functions for caller
  136.  */
  137. CALLER *new_caller(STRPTR name, ULONG posx, ULONG posy)
  138. {
  139.     CALLER *caller = (CALLER *) umalloc(sizeof(CALLER));
  140.  
  141.     caller->name = strclone(name);
  142.     caller->posx = posx;
  143.     caller->posy = posy;
  144.  
  145.     return (caller);
  146. }
  147.  
  148. VOID del_caller(APTR data)
  149. {
  150.     if (data) {
  151.         CALLER *caller = (CALLER *) data;
  152.         ufreestr(caller->name);
  153.         ufree(caller);
  154.     }
  155. }
  156.  
  157. CALLER *fpos2caller(INFILEPOS * fpos)
  158. {
  159.     CALLER *cal = NULL;
  160.  
  161.     if (fpos) {
  162.         cal = new_caller(ifp_get_fname(fpos),
  163.                          ifp_get_x(fpos), ifp_get_y(fpos));
  164.     } else
  165.         cal = new_caller("", 0, 0);
  166.  
  167.     return (cal);
  168. }
  169.  
  170. /*
  171.  * functions for references
  172.  */
  173.  
  174. /* del_reference: remove a reference */
  175. VOID del_reference(APTR data)
  176. {
  177.     HSCREF *ref = (HSCREF *) data;
  178.  
  179.     ufreestr(ref->name);
  180.     del_caller(ref->caller);
  181.     ufree(ref);
  182.     /* NOTE: ref->fpos is removed whith the
  183.      * corresponding file automatically */
  184. }
  185.  
  186. /* new_reference: create a new reference */
  187. HSCREF *new_reference(STRPTR newname)
  188. {
  189.     HSCREF *ref = (HSCREF *) umalloc(sizeof(HSCREF));
  190.  
  191.     if (ref) {
  192.         ref->name = strclone(newname);
  193.         ref->caller = NULL;
  194.     }
  195.     return (ref);
  196. }
  197.  
  198. /*
  199.  * cmp_reference: compare reference
  200.  */
  201. int cmp_reference(APTR cmp_data, APTR list_data)
  202. {
  203.     HSCREF *reference = (HSCREF *) list_data;
  204.     STRPTR fname1 = NULL;
  205.     STRPTR fname2 = (STRPTR) cmp_data;
  206.  
  207. #if DEBUG
  208.     if (!reference)
  209.         panic("reference = NULL");
  210.     else if (!reference->name)
  211.         panic("fname1 = NULL");
  212.     if (!fname2)
  213.         panic("fname2 = NULL");
  214. #endif
  215.     fname1 = reference->name;
  216.  
  217.     if (!strcmp(fname1, fname2))
  218.         return (-1);
  219.     else
  220.         return (0);
  221. }
  222.  
  223. /*
  224.  * app_reference: append new reference to reflist of a document;
  225.  *   if reference already exists, no new ref is added
  226.  */
  227. HSCREF *app_reference(HSCDOC * document, STRPTR ref_name)
  228. {
  229.     HSCREF *ref = NULL;
  230.  
  231.     /* append new reference */
  232.     ref = new_reference(ref_name);
  233.     app_dlnode(document->references, (APTR) ref);
  234. #if 0
  235.     DP(fprintf(stderr, DHP "new reference `%s'\n", ref_name));
  236. #endif
  237.  
  238.     return (ref);
  239. }
  240.  
  241. /*
  242.  * functions for includes
  243.  */
  244.  
  245. /* del_include: remove a include */
  246. VOID del_include(APTR data)
  247. {
  248.     HSCINC *inc = (HSCINC *) data;
  249.  
  250.     ufreestr(inc->name);
  251.     del_caller(inc->caller);
  252.     ufree(inc);
  253. }
  254.  
  255. /* new_include: create a new include */
  256. HSCINC *new_include(STRPTR newname)
  257. {
  258.     HSCINC *inc = (HSCINC *) umalloc(sizeof(HSCINC));
  259.  
  260.     if (inc) {
  261.         inc->name = strclone(newname);
  262.         inc->caller = NULL;
  263.     }
  264.     return (inc);
  265. }
  266.  
  267. /*
  268.  * cmp_include: compare include
  269.  */
  270. int cmp_include(APTR cmp_data, APTR list_data)
  271. {
  272.     HSCINC *include = (HSCINC *) list_data;
  273.     STRPTR fname1 = NULL;
  274.     STRPTR fname2 = (STRPTR) cmp_data;
  275.  
  276. #if DEBUG
  277.     if (!include)
  278.         panic("include = NULL");
  279.     else if (!include->name)
  280.         panic("fname1 = NULL");
  281.     if (!fname2)
  282.         panic("fname2 = NULL");
  283. #endif
  284.     fname1 = include->name;
  285.  
  286.     if (!strcmp(fname1, fname2))
  287.         return (-1);
  288.     else
  289.         return (0);
  290. }
  291.  
  292. /*
  293.  * app_include: append new include to inclist of a document;
  294.  *   even append multiple instancies of the same include
  295.  */
  296. HSCINC *app_include(HSCDOC * document, STRPTR inc_name)
  297. {
  298.     DLNODE *nd = NULL;
  299.     /* append new include */
  300.     HSCINC *inc = new_include(inc_name);
  301.     nd = app_dlnode(document->includes, (APTR) inc);
  302.  
  303.     return (inc);
  304. }
  305.  
  306. /*
  307.  * functions for id-definitions
  308.  */
  309.  
  310. /* del_iddef: remove an id-definition */
  311. VOID del_iddef(APTR data)
  312. {
  313.     HSCIDD *iddef = (HSCIDD *) data;
  314.  
  315.     ufreestr(iddef->name);
  316.     del_caller(iddef->caller);
  317.     if (iddef->fpos)
  318.         del_infilepos(iddef->fpos);
  319.     ufree(iddef);
  320. }
  321.  
  322. /* new_iddef: create a new id-definition */
  323. HSCIDD *new_iddef(STRPTR newname)
  324. {
  325.     HSCIDD *iddef = (HSCIDD *) umalloc(sizeof(HSCIDD));
  326.  
  327.     if (iddef) {
  328.         iddef->name = strclone(newname);
  329.         iddef->caller = NULL;
  330.         iddef->fpos = NULL;
  331.     }
  332.     return (iddef);
  333. }
  334.  
  335. /*
  336.  * debugging printf functions
  337.  */
  338. VOID prt_iddef(FILE * stream, APTR data)
  339. {
  340.     HSCIDD *iddef = (HSCIDD *) data;
  341.     INFILEPOS *fpos = iddef->fpos;
  342.  
  343.     fprintf(stream, "`%s' at (%lu,%lu)\n",
  344.             iddef->name, ifp_get_y(fpos), ifp_get_x(fpos));
  345. }
  346.  
  347. /*
  348.  * cmp_iddef: compare id-definition
  349.  */
  350. int cmp_iddef(APTR cmp_data, APTR list_data)
  351. {
  352.     HSCIDD *iddef = (HSCIDD *) list_data;
  353.     STRPTR fname1 = NULL;
  354.     STRPTR fname2 = (STRPTR) cmp_data;
  355.  
  356. #if DEBUG
  357.     if (!iddef)
  358.         panic("id-definition = NULL");
  359.     else if (!iddef->name)
  360.         panic("fname1 = NULL");
  361.     if (!fname2)
  362.         panic("fname2 = NULL");
  363. #endif
  364.     fname1 = iddef->name;
  365.  
  366.     if (!strcmp(fname1, fname2))
  367.         return (-1);
  368.     else
  369.         return (0);
  370. }
  371.  
  372. /* find_iddef: scans document list for a specific id */
  373. HSCIDD *find_iddef(HSCDOC * document, STRPTR name)
  374. {
  375.     DLNODE *nd = find_dlnode(dll_first(document->iddefs),
  376.                              (APTR) name, cmp_iddef);
  377.     HSCIDD *iddef = NULL;
  378.  
  379.     if (nd)
  380.         iddef = (HSCIDD *) dln_data(nd);
  381.  
  382.     return (iddef);
  383. }
  384.  
  385. /*
  386.  * app_iddef: append new id-definition to iddef-list of a document
  387.  */
  388. HSCIDD *app_iddef(HSCDOC * document, STRPTR iddef_name)
  389. {
  390.     HSCIDD *iddef = NULL;
  391.  
  392.     /* append new id-definition */
  393.     iddef = new_iddef(iddef_name);
  394.     app_dlnode(document->iddefs, (APTR) iddef);
  395. #if 0
  396.     DP(fprintf(stderr, DHP "new id-definition `%s'\n", iddef_name));
  397. #endif
  398.  
  399.     return (iddef);
  400. }
  401.  
  402.